



import bpy
from bpy.types import Operator
from 全局控制.Node.节点和插座基类 import bl_UpdateNode
import 全局控制.Node.节点和插座基类.bl_节点基类 as 基类
import 全局控制.Node.插座.bl_插座基类 as 插件基类
#import 全局控制.Node.节点和插座基类.bl_UpdateNode as 节点插座查找

import pdb


g_合并节点数据传递 = {}


def f_input插座动态增减(self, 剩余数量):
	if len(self.inputs) > 2 :
		for i in range(1, len(self.inputs)):
			l = self.inputs[i]
			if l.is_linked == False:
				self.inputs.remove(l)



class C_SceneNode_流程合并(基类.C_SN_基类): # 
	bl_label = '合并'
	bl_dname = 'bl_node_合并'
	#bl_static_type = 'REROUTE'
	m_Type = 'NODE_合并'
	
	def init(self, context):
		super(C_SceneNode_流程合并, self).f_init(context)

		self.inputs.new('C_NodeSocket_传递', name='分支0')
		#self.inputs.new('C_NodeSocket_传递', name='分支1')
		self.outputs.new('C_NodeSocket_传递', name='总和')

		self.outputs['总和'].f_set功能状态(1)
		g_合并节点数据传递[self.id_data.name + self.name] = []

	#def draw_buttons(self, context, layout):
	#	layout.prop(self, 'm_运算类型')
	def update(self):
		if len(self.inputs) > 2 :
			for i in range(1, len(self.inputs)):
				l = self.inputs[i]
				if l.is_linked == False:
					self.inputs.remove(l)

		self.inputs.new('C_NodeSocket_传递', name='分支'+str(len(self.inputs)))

	def f_input插座Update(self, input插座, 上层Output=None):
		#print('--------------- 上层Output = ', input插座.name, 上层Output)
		if input插座.name != '_>' :
			f_递归到子节点Update(input插座, 上层Output)
		super(C_SceneNode_流程合并, self).f_input插座Update(input插座, 上层Output)

	def f_update(self, 是否向下传递=False, input插座=None):
		#print('C_SceneNode_流程合并 = ', self)
		#for out in self.outputs :
			#if out.is_linked:
		#	bl_UpdateNode.f_递归到子节点Update(self.outputs, 是否向下传递)
		self.m_是否要更新 = False

		for input in self.inputs :

			pass
		super(C_SceneNode_流程合并, self).f_update(是否向下传递, input插座)
		return False

	def f_is强制Update(self):
		return True


class C_NODE_AddMenu_流程合并(bpy.types.Operator):
	bl_idname = 'node.global_node_process_merge'
	bl_label = 'Add 合并节点'
	bl_options = {'REGISTER', 'UNDO'}
	
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_SceneNode_流程合并', use_transform=True)
		return {'FINISHED'}









class C_Node_选择有输入项(基类.C_SN_基类):
	bl_dname = 'bl_node_选择有输入项'
	bl_label = '选择有输入项'
	
	def init(self, context):
		super(C_Node_选择有输入项, self).f_init(context)

		self.inputs.new('C_NodeSocket_通用', name='分支0')
		self.outputs.new('C_NodeSocket_通用', name='总和')

		g_合并节点数据传递['合并节点数据_' + self.id_data.name + '_' + self.name] = {}

	def update(self):
		f_input插座动态增减(self, 2)
		self.inputs.new('C_NodeSocket_通用', name='分支'+str(len(self.inputs)))

	def f_input插座Update(self, input插座, 上层Output=None):
		if input插座.name != '_>' :
			
			输入插座数据 = {}
			try:
				输入插座数据 = g_合并节点数据传递['合并节点数据_' + self.id_data.name + '_' + self.name]
			except :
				g_合并节点数据传递['合并节点数据_' + self.id_data.name + '_' + self.name] = 输入插座数据
				
			输入插座数据[input插座.name] = 上层Output.f_getData()

			#输入插座设为已更新 在判断节点是否为需要更新的情况下 直接通过
			if 输入插座数据[input插座.name] != None :
				input插座.f_标记为以更新()

		super(C_Node_选择有输入项, self).f_input插座Update(input插座, 上层Output)
		#print(' ---- A 输入插座数据[input插座.name] --- ', input插座.name, self.f_is未更新(), input插座.f_getData())


	def f_update(self, 是否向下传递=False, input插座=None):
		输入插座数据 = g_合并节点数据传递['合并节点数据_' + self.id_data.name + '_' + self.name]
		data = None
		for input in self.inputs :
			if input.is_linked and input.name != '_<' and (input.name in 输入插座数据.keys()) :
				data = 输入插座数据[input.name]
				if data != None :
					#bl_UpdateNode.f_递归到子节点Update(self.outputs, 是否向下传递)
					break

		if data != None :
			self.outputs['总和'].f_setData(data)
			g_合并节点数据传递['合并节点数据_' + self.id_data.name + '_' + self.name] = {}
		#print(' ---- B 输入插座数据[input插座.name] --- ', data)
		super(C_Node_选择有输入项, self).f_update(是否向下传递, input插座)

		for input in self.inputs :
			input.f_setData(None)

		return False

	def f_is强制Update(self):
		#print(' == self.f_is以更新() == ', self.f_is以更新())
		if self.f_is以更新() :
			return True
		return False
	def f_pushUpdate(self):
		for i in self.inputs:
			data = i.f_getData(10000)
			
			if i.name != '_>' and data != None :
				#print(' == mbt data == ', i.name, data)
				self.m_是否要更新 = True
				return
		self.m_是否要更新 = False
	def f_标记为已更新(self):
		#pdb.set_trace()
		print(' == mbt self.m_是否要更新 == ', self.m_是否要更新)
		#self.m_是否要更新 = False

class C_NODE_AddMenu_选择有输入项(bpy.types.Operator):
	bl_idname = 'node.global_node_margin_top'
	bl_label = '选择有输入项'
	bl_options = {'REGISTER', 'UNDO'}
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_Node_选择有输入项', use_transform=True)
		return {'FINISHED'}




classes = (
	C_SceneNode_流程合并,
	C_NODE_AddMenu_流程合并,
	
	C_Node_选择有输入项,
	C_NODE_AddMenu_选择有输入项,


)




def register():
	for c in classes:
		bpy.utils.register_class(c)
		
	


def unregister():
	for c in classes:
		bpy.utils.unregister_class(c)

	

